/**
 * 2015，thor.com，all rights reserved。
 * 
 * Project：		thor-common
 * Filename：	QueryDefinitionDecoder.java
 * Created：		2015年3月14日
 * Creator：		thor
 */
package com.jeecg.query;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * @author thor
 * 
 */
@SuppressWarnings("rawtypes")
public class QueryDefinitionDecoder {
  /**
   * 创建对象。
   */
  public QueryDefinitionDecoder() {
    // Do Nothing
  }

  /**
   * 创建对象。
   * 
   * @param entityClass
   *          实体类型。
   * @param alias
   *          别名，传入null将自动分配一个。
   */
  public QueryDefinitionDecoder(Class entityClass, String alias) {
    this();
    this.masterEntityClass = entityClass;
    this.masterEntityAlias = alias;
  }

  private Class masterEntityClass;
  private String masterEntityAlias;
  private QueryConditionDecoder conditionDecoder;
  private QueryOrderDecoder orderDecoder;
  private List<String> selectClauses = new ArrayList<String>();
  private List<JoinEntity> joinEntities = new ArrayList<JoinEntity>();

  /**
   * 取得主实体类型。
   * 
   * @return 主实体类型
   */
  public Class getMasterEntityClass() {
    return masterEntityClass;
  }

  /**
   * 取得主实体别名。
   * 
   * @return 主实体别名
   */
  public String getMasterEntityAlias() {
    return masterEntityAlias;
  }

  /**
   * 设置主实体。
   * 
   * @param entityClass
   *          实体类型。
   * @param alias
   *          别名，传入null将自动分配一个。
   */
  public void setMasterEntity(Class entityClass, String alias) {

    this.masterEntityClass = entityClass;
    this.masterEntityAlias = alias;
  }

  public void addJoinEntity(JoinEntity joinEntity) {
    joinEntities.add(joinEntity);
  }

  /** 查询条件解码器对象。 */
  public QueryConditionDecoder getConditionDecoder() {
    return conditionDecoder;
  }

  public void setConditionDecoder(QueryConditionDecoder conditionDecoder) {
    this.conditionDecoder = conditionDecoder;
  }

  /** 排序条件解码器对象。 */
  public QueryOrderDecoder getOrderDecoder() {
    return orderDecoder;
  }

  public void setOrderDecoder(QueryOrderDecoder orderDecoder) {
    this.orderDecoder = orderDecoder;
  }

  public void addSelect(String... fields) {
    for (String field : fields) {
      selectClauses.add(field);
    }
  }

  /**
   * 对基于语义的查询定义对象进行解码，将返回可指定的查询定义对象。
   * 
   * @param definition
   *          若传入null将导致返回null。
   * @return 指定的查询定义对象
   */
  public SQLSubquery decode(QueryDefinition definition) {
    if (definition == null) {
      return null;
    }
    if (definition.getConditions().size() > 0 && conditionDecoder == null) {
      throw new UnsupportedOperationException(
          MessageFormat.format("必须提供有效的属性{0}。", "conditionDecoder"));
    }

    if (definition.getOrders().size() > 0 && orderDecoder == null) {
      throw new UnsupportedOperationException(
          MessageFormat.format("必须提供有效的属性{0}。", "orderDecoder"));
    }

    SQLSubquery subquery = new SQLSubquery();
    subquery.addSelect(selectClauses.toArray(new String[] {}));
    subquery.setMasterEntityAlias(masterEntityAlias);
    subquery.setMasterEntityClass(masterEntityClass);
    for (JoinEntity joinEntity : joinEntities) {
      subquery.addJoinEntity(joinEntity);
    }

    for (QueryCondition condition : definition.getConditions()) {
      if (condition != null && condition.getOperation() != null) {
        conditionDecoder.decodeCondition(condition, subquery);
      }
    }

    for (QueryOrder order : definition.getOrders()) {
      if (order != null && order.getField() != null) {
        orderDecoder.decodeOrder(order, subquery);
      }
    }
    return subquery;
  }
}
